home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / language / asxsrc.arc / M11ADR.C < prev    next >
C/C++ Source or Header  |  1991-06-10  |  3KB  |  195 lines
  1. /* m11adr.c */
  2.  
  3. /*
  4.  * (C) Copyright 1989
  5.  * All Rights Reserved
  6.  *
  7.  * Alan R. Baldwin
  8.  * 721 Berkeley St.
  9.  * Kent, Ohio  44240
  10.  */
  11.  
  12. #include <stdio.h>
  13. #include <setjmp.h>
  14. #include "asm.h"
  15. #include "6811.h"
  16.  
  17. int
  18. addr(esp)
  19. register struct expr *esp;
  20. {
  21.     register c;
  22.     register struct area *espa;
  23.     register char *tcp;
  24.  
  25.     if ((c = getnb()) == '#') {
  26.         expr(esp, 0);
  27.         esp->e_mode = S_IMMED;
  28.     } else
  29.     if (c == ',') {
  30.         esp->e_mode = 0;
  31.         esp->e_flag = 0;
  32.         esp->e_addr = 0;
  33.         esp->e_base.e_ap = NULL;
  34.         c = admode(abdxy);
  35.         if (c == S_X) {
  36.             esp->e_mode = S_INDX;
  37.         } else
  38.         if (c == S_Y) {
  39.             esp->e_mode = S_INDY;
  40.         } else {
  41.             aerr();
  42.         }
  43.     } else
  44.     if (c == '*') {
  45.         expr(esp, 0);
  46.         esp->e_mode = S_DIR;
  47.         espa = esp->e_base.e_ap;
  48.         if (esp->e_addr & ~0xFF)
  49.             aerr();
  50.         if (espa && espa != sdp->s_area)
  51.             rerr();
  52.         if (more()) {
  53.             comma();
  54.             tcp = ip;
  55.             if (c = admode(abdxy)) {
  56.                 if (c == S_X) {
  57.                     esp->e_mode = S_INDX;
  58.                 } else
  59.                 if (c == S_Y) {
  60.                     esp->e_mode = S_INDY;
  61.                 } else {
  62.                     aerr();
  63.                 }
  64.             } else {
  65.                 ip = --tcp;
  66.             }
  67.         }
  68.     } else {
  69.         unget(c);
  70.         if (esp->e_mode = admode(abdxy)) {
  71.             ;
  72.         } else {
  73.             expr(esp, 0);
  74.             if (more()) {
  75.                 tcp = ip;
  76.                 comma();
  77.                 if (c = admode(abdxy)) {
  78.                     if (c == S_X) {
  79.                         esp->e_mode = S_INDX;
  80.                     } else
  81.                     if (c == S_Y) {
  82.                         esp->e_mode = S_INDY;
  83.                     } else {
  84.                         aerr();
  85.                     }
  86.                     if (c == S_X || c == S_Y) {
  87.                         espa = esp->e_base.e_ap;
  88.                         if (esp->e_addr & ~0xFF)
  89.                             aerr();
  90.                         if (espa &&
  91.                             espa != sdp->s_area)
  92.                             rerr();
  93.                     }
  94.                 } else {
  95.                     ip = --tcp;
  96.                 }
  97.             } else {
  98.                 if ( !esp->e_base.e_ap &&
  99.                     !(esp->e_addr & ~0xFF)) {
  100.                     esp->e_mode = S_DIR;
  101.                 } else {
  102.                     esp->e_mode = S_EXT;
  103.                 }
  104.             }
  105.         }
  106.     }
  107.     return (esp->e_mode);
  108. }
  109.     
  110. /*
  111.  * Enter admode() to search a specific addressing mode table
  112.  * for a match. Return the addressing value on a match or
  113.  * zero for no match.
  114.  */
  115. int
  116. admode(sp)
  117. register struct adsym *sp;
  118. {
  119.     register char *ptr;
  120.     register int i;
  121.     unget(getnb());
  122.     i = 0;
  123.     while ( *(ptr = (char *) &sp[i].a_str) ) {
  124.         if (srch(ptr)) {
  125.             return(sp[i].a_val);
  126.         }
  127.         i++;
  128.     }
  129.     return(0);
  130. }
  131.  
  132. /*
  133.  *      srch --- does string match ?
  134.  */
  135. int
  136. srch(str)
  137. register char *str;
  138. {
  139.     register char *ptr;
  140.     ptr = ip;
  141.  
  142. #if    CASE_SENSITIVE
  143.     while (*ptr && *str) {
  144.         if(*ptr != *str)
  145.             break;
  146.         ptr++;
  147.         str++;
  148.     }
  149.     if (*ptr == *str) {
  150.         ip = ptr;
  151.         return(1);
  152.     }
  153. #else
  154.     while (*ptr && *str) {
  155.         if(ccase[*ptr] != ccase[*str])
  156.             break;
  157.         ptr++;
  158.         str++;
  159.     }
  160.     if (ccase[*ptr] == ccase[*str]) {
  161.         ip = ptr;
  162.         return(1);
  163.     }
  164. #endif
  165.  
  166.     if (!*str)
  167.         if (any(*ptr," \t\n,];")) {
  168.             ip = ptr;
  169.             return(1);
  170.         }
  171.     return(0);
  172. }
  173.  
  174. /*
  175.  *      any --- does str contain c?
  176.  */
  177. int
  178. any(c,str)
  179. char    c, *str;
  180. {
  181.     while (*str)
  182.         if(*str++ == c)
  183.             return(1);
  184.     return(0);
  185. }
  186.  
  187. struct adsym    abdxy[] = {    /* a, b, d, x, or y registers */
  188.     "a",    S_A,
  189.     "b",    S_B,
  190.     "d",    S_D,
  191.     "x",    S_X,
  192.     "y",    S_Y,
  193.     "",    0x00
  194. };
  195.